JavaScripti generaatorfunktsiooni asünkroonse kompositsiooni: mitme generaatori koordineerimine

JavaScripti generaatorfunktsioonid pakuvad võimsa mehhanismi asünkroonsete toimingute käsitlemiseks sünkroonsema väljanägemisega viisil. Kuigi generaatorite põhikasutus on hästi dokumenteeritud, peitub nende tõeline potentsiaal nende võimes olla komponeeritud ja koordineeritud, eriti kui tegemist on mitme asünkroonse andmevooga. See postitus süveneb täiustatud tehnikatesse mitme generaatori koordineerimise saavutamiseks asünkroonsete kompositsioonide abil.

Generaatorfunktsioonide mõistmine

Enne kompositsiooni sukeldumist vaatame kiiresti üle, mis on generaatorfunktsioonid ja kuidas need töötavad.

Generaatorfunktsioon deklareeritakse süntaksiga function*. Erinevalt tavalistest funktsioonidest saab generaatorfunktsioone täitmise ajal peatada ja jätkata. Võtmesõna yield kasutatakse funktsiooni peatamiseks ja väärtuse tagastamiseks. Kui generaatori tööd jätkatakse (kasutades next()), jätkub täitmine sealt, kus see pooleli jäi.

Siin on lihtne näide:

            function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

const generator = numberGenerator();

console.log(generator.next()); // Output: { value: 1, done: false }
console.log(generator.next()); // Output: { value: 2, done: false }
console.log(generator.next()); // Output: { value: 3, done: false }
console.log(generator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

Asünkroonsed generaatorid

Asünkroonsete toimingute käsitlemiseks saame kasutada asünkroonseid generaatoreid, mis deklareeritakse süntaksiga async function*. Need generaatorid saavad await lubadusi, võimaldades asünkroonse koodi kirjutamist lineaarsema ja loetavama stiilina.

Näide:

            async function* fetchUsers(userIds) {
  for (const userId of userIds) {
    const response = await fetch(`https://api.example.com/users/${userId}`);
    const user = await response.json();
    yield user;
  }
}

async function main() {
  const userIds = [1, 2, 3];
  const userGenerator = fetchUsers(userIds);

  for await (const user of userGenerator) {
    console.log(user);
  }
}

main();

            

              
                Copy
              
            
          

Selles näites on fetchUsers asünkroonne generaator, mis hangib kasutaja andmeid API-st iga esitatud userId jaoks. Tsüklit for await...of kasutatakse asünkroonse generaatori itereerimiseks, oodates iga väljastatud väärtust enne selle töötlemist.

Vajadus mitme generaatori koordineerimise järele

Sageli nõuavad rakendused koordineerimist mitme asünkroonse andmeallika või töötlemisetapi vahel. Näiteks võib teil olla vaja:

• Hankida andmeid mitmest API-st samaaegselt.
• Töödelda andmeid läbi rea teisendusi, millest igaüht teostab eraldi generaator.
• Käsitleda vigu ja erandeid mitme asünkroonse toimingu puhul.
• Rakendada keerukat juhtimisvoo loogikat, näiteks tingimuslik täitmine või fan-out/fan-in mustrid.

Traditsioonilisi asünkroonseid programmeerimistehnikaid, nagu tagasihelistamised või lubadused, võib nendes stsenaariumides olla raske hallata. Generaatorfunktsioonid pakuvad struktureeritumat ja komponeeritavamat lähenemisviisi.

Tehnikad mitme generaatori koordineerimiseks

Siin on mitu tehnikat mitme generaatorfunktsiooni koordineerimiseks:

1. Generaatori kompositsioon koos `yield*`

Võtmesõna yield* võimaldab teil delegeerida teisele iteraatorile või generaatorfunktsioonile. See on generaatorite komponeerimise põhiline ehitusplokk. See sisuliselt "lamendab" delegeeritud generaatori väljundi praeguse generaatori väljundvoogu.

Näide:

            async function* generatorA() {
  yield 1;
  yield 2;
}

async function* generatorB() {
  yield 3;
  yield 4;
}

async function* combinedGenerator() {
  yield* generatorA();
  yield* generatorB();
}

async function main() {
  for await (const value of combinedGenerator()) {
    console.log(value); // Output: 1, 2, 3, 4
  }
}

main();

            

              
                Copy
              
            
          

Selles näites väljastab combinedGenerator kõik väärtused generaatorist generatorA ja seejärel kõik väärtused generaatorist generatorB. See on lihtne järjestikuse kompositsiooni vorm.

2. Samaaegne täitmine koos `Promise.all`

Mitme generaatori samaaegseks täitmiseks saate need ümbritseda lubadustega ja kasutada Promise.all. See võimaldab teil hankida andmeid mitmest allikast paralleelselt, parandades jõudlust.

Näide:

            async function* fetchUserData(userId) {
  const response = await fetch(`https://api.example.com/users/${userId}`);
  const user = await response.json();
  yield user;
}

async function* fetchPosts(userId) {
  const response = await fetch(`https://api.example.com/users/${userId}/posts`);
  const posts = await response.json();
  for (const post of posts) {
    yield post;
  }
}

async function* combinedGenerator(userId) {
  const userDataPromise = fetchUserData(userId).next();
  const postsPromise = fetchPosts(userId).next();

  const [userDataResult, postsResult] = await Promise.all([userDataPromise, postsPromise]);

  if (userDataResult.value) {
    yield { type: 'user', data: userDataResult.value };
  }
  if (postsResult.value) {
    yield { type: 'posts', data: postsResult.value };
  }
}

async function main() {
  for await (const item of combinedGenerator(1)) {
    console.log(item);
  }
}

main();

            

              
                Copy
              
            
          

Selles näites hangib combinedGenerator kasutaja andmeid ja postitusi samaaegselt kasutades Promise.all. Seejärel väljastab see tulemused eraldi objektidena, millel on atribuut type, et näidata andmeallikat.

Oluline kaalutlus: `.next()` kasutamine generaatoril enne iteratsiooni koos `for await...of` edastab iteraatorit *üks kord*. Seda on ülioluline mõista, kui kasutate Promise.all koos generaatoritega, kuna see alustab generaatori täitmist ennetavalt.

3. Fan-Out/Fan-In mustrid

Fan-out/fan-in muster on tavaline muster töö jaotamiseks mitme töötaja vahel ja seejärel tulemuste agregeerimiseks. Generaatorfunktsioone saab kasutada selle mustri tõhusaks rakendamiseks.

Fan-Out: Ülesannete jaotamine mitmele generaatorile.

Fan-In: Tulemuste kogumine mitmelt generaatorilt.

Näide:

            async function* worker(taskId) {
  // Simuleeri asünkroonset tööd
  await new Promise(resolve => setTimeout(resolve, Math.random() * 1000));
  yield { taskId, result: `Result for task ${taskId}` };
}

async function* fanOut(taskIds, numWorkers) {
  const workerGenerators = [];
  for (let i = 0; i < numWorkers; i++) {
    workerGenerators.push(worker(taskIds[i % taskIds.length])); // Round-robin ülesanne
  }

  for (let i = 0; i < taskIds.length; i++) {
      yield* workerGenerators[i % numWorkers];
  }
}

async function main() {
  const taskIds = [1, 2, 3, 4, 5, 6, 7, 8];
  const numWorkers = 3;

  for await (const result of fanOut(taskIds, numWorkers)) {
    console.log(result);
  }
}

main();

            

              
                Copy
              
            
          

Selles näites jaotab fanOut ülesanded (simuleeritud funktsiooniga worker) fikseeritud arvule töötajatele. Round-robin ülesanne tagab suhteliselt ühtlase tööjaotuse. Tulemused väljastatakse seejärel generaatorist fanOut. Pange tähele, et selles lihtsustatud näites ei tööta töötajad tegelikult samaaegselt; yield* sunnib järjestikust täitmist funktsioonis fanOut.

4. Sõnumite edastamine generaatorite vahel

Generaatorid saavad omavahel suhelda, edastades väärtusi edasi-tagasi meetodi next() abil. Kui kutsute generaatoril next(value), edastatakse value generaatori sees olevale avaldisele yield.

Näide:

            async function* producer() {
  let message = 'Esialgne sõnum';
  while (true) {
    const received = yield message;
    console.log(`Tootja sai: ${received}`);
    message = `Tootja vastus: ${received}`;
    await new Promise(resolve => setTimeout(resolve, 500)); // Simuleeri mõnda tööd
  }
}

async function* consumer(producerGenerator) {
  let message = 'Tarbija alustab';
  let result = await producerGenerator.next();
  console.log(`Tarbija sai tootjalt: ${result.value}`);

  while (!result.done) {
    const response = `Tarbija sõnum: ${message}`; // Loo vastus
    result = await producerGenerator.next(response); // Saada sõnum tootjale
    if (!result.done) {
        console.log(`Tarbija sai tootjalt: ${result.value}`); // logi vastus tootjalt
    }
    message = `Järgmine tarbija sõnum`; // Loo järgmine sõnum järgmisel iteratsioonil saatmiseks
    await new Promise(resolve => setTimeout(resolve, 500)); // Simuleeri mõnda tööd
  }
}

async function main() {
  const prod = producer();
  await consumer(prod);
}

main();

            

              
                Copy
              
            
          

Selles näites saadab consumer sõnumeid producer-ile, kasutades producerGenerator.next(response), ja producer saab need sõnumid avaldise yield abil. See võimaldab generaatorite vahel kahesuunalist sidet.

5. Veakäsitlus

Veakäsitlus asünkroonsetes generaatorikompositsioonides nõuab hoolikat kaalumist. Saate kasutada try...catch plokke generaatorites, et käsitleda asünkroonsete toimingute ajal ilmnevaid vigu.

Näide:

            async function* safeFetch(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP viga! staatus: ${response.status}`);
    }
    const data = await response.json();
    yield data;
  } catch (error) {
    console.error(`Viga andmete hankimisel aadressilt ${url}: ${error}`);
    yield { error: error.message, url }; // Väljasta veateade
  }
}

async function main() {
  const generator = safeFetch('https://api.example.com/data'); // Asenda tegeliku URL-iga, kuid veendu, et see testiks olemas

  for await (const result of generator) {
    if (result.error) {
      console.log(`Andmete hankimine aadressilt ${result.url} ebaõnnestus: ${result.error}`);
    } else {
      console.log('Hangitud andmed:', result);
    }
  }
}

main();

            

              
                Copy
              
            
          

Selles näites püüab safeFetch generaator kõik vead, mis fetch toimingu ajal ilmnevad, ja väljastab veaobjekti. Seejärel saab kutsuv kood kontrollida vea olemasolu ja seda vastavalt käsitleda.

Praktilised näited ja kasutusjuhud

Siin on mõned praktilised näited ja kasutusjuhud, kus mitme generaatori koordineerimine võib olla kasulik:

• Andmevoogedastus: Suurte andmekogumite tükkidena töötlemine generaatorite abil, kus mitu generaatorit teostavad andmevoos samaaegselt erinevaid teisendusi. Kujutage ette väga suure logifaili töötlemist: üks generaator võib faili lugeda, teine ​​võib ridu parsideerida ja kolmas võib statistikat agregeerida.
• Reaalajas andmetöötlus: Reaalajas andmevoogude käsitlemine mitmest allikast, nagu andurid või aktsiate tickerid, kasutades generaatoreid andmete filtreerimiseks, teisendamiseks ja agregeerimiseks.
• Mikroteenuste orkestreerimine: Mitmele mikroteenusele helistamise koordineerimine generaatorite abil, kus iga generaator esindab kõnet erinevale teenusele. See võib lihtsustada keerukaid töövooge, mis hõlmavad interaktsioone mitme teenuse vahel. Näiteks võib e-kaubanduse tellimuste töötlemise süsteem hõlmata kõnesid makseteenusele, laoteenusele ja saatmisteenusele.
• Mängude arendus: Keeruka mänguloogika rakendamine generaatorite abil, kus mitu generaatorit kontrollivad mängu erinevaid aspekte, nagu AI, füüsika ja renderdamine.
• ETL (Extract, Transform, Load) protsessid: ETL torujuhtmete sujuvamaks muutmine generaatorfunktsioonide abil andmete eraldamiseks erinevatest allikatest, nende teisendamiseks soovitud vormingusse ja laadimiseks sihtandmebaasi või andmelattu. Iga sammu (Extract, Transform, Load) saab rakendada eraldi generaatorina, võimaldades modulaarset ja taaskasutatavat koodi.

Generaatorfunktsioonide eelised asünkroonseks kompositsiooniks

• Parem loetavus: Generaatorite abil kirjutatud asünkroonne kood võib olla loetavam ja kergemini mõistetav kui tagasihelistamiste või lubadustega kirjutatud kood.
• Lihtsustatud veakäsitlus: Generaatorfunktsioonid lihtsustavad veakäsitlust, võimaldades kasutada try...catch plokke asünkroonsete toimingute ajal ilmnevate vigade püüdmiseks.
• Suurenenud komponeeritavus: Generaatorfunktsioonid on väga komponeeritavad, võimaldades hõlpsasti kombineerida mitu generaatorit, et luua keerukaid asünkroonseid töövooge.
• Täiustatud hooldatavus: Generaatorfunktsioonide modulaarsus ja komponeeritavus muudavad koodi hooldamise ja värskendamise lihtsamaks.
• Parem testitavus: Generaatorfunktsioone on lihtsam testida kui tagasihelistamiste või lubadustega kirjutatud koodi, kuna saate hõlpsasti kontrollida täitmise voogu ja simuleerida asünkroonseid toiminguid.

Väljakutsed ja kaalutlused

• Õppimiskõver: Generaatorfunktsioone võib olla keerulisem mõista kui traditsioonilisi asünkroonseid programmeerimistehnikaid.
• Silumine: Asünkroonsete generaatorikompositsioonide silumine võib olla keeruline, kuna täitmise voogu võib olla raske jälgida. Heade logimispraktikate kasutamine on ülioluline.
• Jõudlus: Kuigi generaatorid pakuvad loetavuse eeliseid, võib vale kasutamine põhjustada jõudluse kitsaskohti. Olge teadlik generaatorite vahel konteksti vahetamise kuludest, eriti jõudluskriitilistes rakendustes.
• Brauseri tugi: Kuigi kaasaegsed brauserid toetavad üldiselt hästi generaatorfunktsioone, veenduge vajadusel vanemate brauserite ühilduvuses.
• Üldkulu: Generaatoritel on konteksti vahetamise tõttu traditsioonilise async/await ees väike üldkulu. Mõõtke jõudlust, kui see on teie rakenduses kriitiline.

Parimad tavad

• Hoidke generaatorid väikesed ja fokuseeritud: Iga generaator peaks täitma ühe, hästi määratletud ülesande. See parandab loetavust ja hooldatavust.
• Kasutage kirjeldavaid nimesid: Kasutage generaatorfunktsioonide ja muutujate jaoks selgeid ja kirjeldavaid nimesid.
• Dokumenteerige oma kood: Dokumenteerige oma kood põhjalikult, selgitades iga generaatori eesmärki ja seda, kuidas see teiste generaatoritega suhtleb.
• Testige oma koodi: Testige oma koodi põhjalikult, sealhulgas ühikteste ja integratsiooniteste.
• Kasutage lintersit ja koodivormindajat: Kasutage lintersit ja koodivormindajat, et tagada koodi järjepidevus ja kvaliteet.
• Kaaluge raamatukogu kasutamist: Raamatukogud, nagu co või iter-tools, pakuvad utiliite generaatoritega töötamiseks ja võivad lihtsustada tavalisi ülesandeid.

Järeldus

JavaScripti generaatorfunktsioonid, kui neid kombineerida asünkroonsete programmeerimistehnikatega, pakuvad võimsa ja paindliku lähenemisviisi keerukate asünkroonsete töövoogude haldamiseks. Valdades mitme generaatori komponeerimise ja koordineerimise tehnikaid, saate luua puhtamat, hallatavamat ja hooldatavamat koodi. Kuigi on väljakutseid ja kaalutlusi, millest tuleb teadlik olla, kaaluvad generaatorfunktsioonide kasutamise eelised asünkroonseks kompositsiooniks sageli üles puudused, eriti keerukates rakendustes, mis nõuavad koordineerimist mitme asünkroonse andmeallika või töötlemisetapi vahel. Katsetage selles postituses kirjeldatud tehnikatega ja avastage mitme generaatori koordineerimise jõud oma projektides.